package com.terabits.smartriver.util;

import com.mongodb.DB;
import com.mongodb.gridfs.GridFS;
import com.mongodb.gridfs.GridFSDBFile;
import com.mongodb.gridfs.GridFSInputFile;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Sort;
import org.springframework.data.domain.Sort.Direction;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.data.mongodb.core.query.Update;
import org.springframework.stereotype.Component;
import org.springframework.web.multipart.MultipartFile;

import java.io.IOException;
import java.util.List;

/**
 * mongodb curd 工具类
 */
@Component
public class MongoManager {

    @Autowired
    private MongoTemplate mongoTemplate;

    private DB getDB() {
        return mongoTemplate.getMongoDbFactory().getLegacyDb();
    }

    public String insertGridFS(String bucket, MultipartFile file, String fileName) throws IOException {
        GridFS gridFS = new GridFS(getDB(), bucket);
        GridFSInputFile gridFSFile = gridFS.createFile(file.getBytes());
        if (fileName == null) {
            fileName = UUIDUtils.getUUID32();
        }
        gridFSFile.setFilename(fileName);
        gridFSFile.setContentType(file.getContentType());
        gridFSFile.put("realFileName", file.getOriginalFilename());
        gridFSFile.save();
        return fileName;
    }

    public void deleteGridFS(String bucket, String fileName) {
        GridFS gridFS = new GridFS(getDB(), bucket);
        gridFS.remove(fileName);
    }

    public GridFSDBFile selectGridFS(String bucket, String fileName) {
        GridFS gridFS = new GridFS(mongoTemplate.getMongoDbFactory().getLegacyDb(), bucket);
        GridFSDBFile gridFSFile = gridFS.findOne(fileName);
        return gridFSFile;
    }

//    ====================================== 以上是GridFS ====================================================================

    /**
     * 保存数据对象，集合为数据对象中@Document 注解所配置的collection
     *
     * @param obj 数据对象
     */
    public void save(Object obj) {
        mongoTemplate.save(obj);
    }

    /**
     * 指定集合保存数据对象
     *
     * @param obj            数据对象
     * @param collectionName 集合名
     */
    public void save(Object obj, String collectionName) {
        mongoTemplate.save(obj, collectionName);
    }

    /**
     * 根据数据对象中的id删除数据，集合为数据对象中@Document 注解所配置的collection
     *
     * @param obj 数据对象
     */
    public void remove(Object obj) {

        mongoTemplate.remove(obj);
    }

    /**
     * 指定集合 根据数据对象中的id删除数据
     *
     * @param obj            数据对象
     * @param collectionName 集合名
     */
    public void remove(Object obj, String collectionName) {

        mongoTemplate.remove(obj, collectionName);
    }

    /**
     * 根据key，value到指定集合删除数据
     *
     * @param key            键
     * @param value          值
     * @param collectionName 集合名
     */
    public void removeById(String key, Object value, String collectionName) {

        Criteria criteria = Criteria.where(key).is(value);
        criteria.and(key).is(value);
        Query query = Query.query(criteria);
        mongoTemplate.remove(query, collectionName);
    }

    /**
     * 指定集合 修改数据，且仅修改找到的第一条数据
     *
     * @param accordingKey   修改条件 key
     * @param accordingValue 修改条件 value
     * @param updateKeys     修改内容 key数组
     * @param updateValues   修改内容 value数组
     * @param collectionName 集合名
     */
    public void updateFirst(String accordingKey, Object accordingValue, String[] updateKeys, Object[] updateValues, String collectionName) {

        Criteria criteria = Criteria.where(accordingKey).is(accordingValue);
        Query query = Query.query(criteria);
        Update update = new Update();
        for (int i = 0; i < updateKeys.length; i++) {
            update.set(updateKeys[i], updateValues[i]);
        }
        mongoTemplate.updateFirst(query, update, collectionName);
    }

    /**
     * 指定集合 修改数据，且修改所找到的所有数据
     *
     * @param accordingKey   修改条件 key
     * @param accordingValue 修改条件 value
     * @param updateKeys     修改内容 key数组
     * @param updateValues   修改内容 value数组
     * @param collectionName 集合名
     */
    public void updateMulti(String accordingKey, Object accordingValue, String[] updateKeys, Object[] updateValues, String collectionName) {
        Criteria criteria = Criteria.where(accordingKey).is(accordingValue);
        Query query = Query.query(criteria);
        Update update = new Update();
        for (int i = 0; i < updateKeys.length; i++) {
            update.set(updateKeys[i], updateValues[i]);
        }
        mongoTemplate.updateMulti(query, update, collectionName);
    }

    /**
     * 根据条件查询出所有结果集 集合为数据对象中@Document 注解所配置的collection
     *
     * @param obj        数据对象
     * @param findKeys   查询条件 key
     * @param findValues 查询条件 value
     * @return
     */
    public List<? extends Object> find(Object obj, String[] findKeys, Object[] findValues) {
        Query query = getQuery(findKeys, findValues);
        List<? extends Object> resultList = mongoTemplate.find(query, obj.getClass());
        return resultList;
    }

    /**
     * 指定集合 根据条件查询出所有结果集
     *
     * @param obj            数据对象
     * @param findKeys       查询条件 key
     * @param findValues     查询条件 value
     * @param collectionName 集合名
     * @return
     */
    public List<? extends Object> find(Object obj, String[] findKeys, Object[] findValues, String collectionName) {
        Query query = getQuery(findKeys, findValues);
        List<? extends Object> resultList = mongoTemplate.find(query, obj.getClass(), collectionName);
        return resultList;
    }

    /**
     * 指定集合 根据条件查询出所有结果集 并排倒序
     *
     * @param obj            数据对象
     * @param findKeys       查询条件 key
     * @param findValues     查询条件 value
     * @param collectionName 集合名
     * @param sort           排序字段
     * @return
     */
    public List<? extends Object> find(Object obj, String[] findKeys, Object[] findValues, String collectionName, String sort) {
        Query query = getQuery(findKeys, findValues);
        query.with(new Sort(Direction.DESC, sort));
        List<? extends Object> resultList = mongoTemplate.find(query, obj.getClass(), collectionName);
        return resultList;
    }

    /**
     * 指定集合 根据条件查询出所有结果集 并排倒序
     *
     * @param obj            数据对象
     * @param findKeys       查询条件 key
     * @param findValues     查询条件 value
     * @param findKey        范围查找字段
     * @param gt             最小值
     * @param lt             最大值
     * @param collectionName 集合名
     * @param sort           排序字段
     * @return
     */
    public List<? extends Object> find(Object obj, String[] findKeys, Object[] findValues, String findKey, String gt, String lt, String collectionName, String sort) {
        Query query = getQuery(findKeys, findValues, findKey, gt, lt);
        query.with(new Sort(Direction.DESC, sort));
        List<? extends Object> resultList = mongoTemplate.find(query, obj.getClass(), collectionName);
        return resultList;
    }

    /**
     * 指定集合 根据条件查询出所有结果集 并排倒序
     *
     * @param obj            数据对象
     * @param findKey        范围查找字段
     * @param gt             最小值
     * @param lt             最大值
     * @param collectionName 集合名
     * @param sort           排序字段
     * @return
     */
    public List<? extends Object> find(Object obj, String findKey, String gt, String lt, String collectionName, String sort) {
        Query query = getQuery(findKey, gt, lt);
        query.with(new Sort(Direction.DESC, sort));
        List<? extends Object> resultList = mongoTemplate.find(query, obj.getClass(), collectionName);
        return resultList;
    }

    /**
     * 根据条件查询出符合的第一条数据 集合为数据对象中 @Document 注解所配置的collection
     *
     * @param obj        数据对象
     * @param findKeys   查询条件 key
     * @param findValues 查询条件 value
     * @return
     */
    public Object findOne(Object obj, String[] findKeys, Object[] findValues) {
        Query query = getQuery(findKeys, findValues);
        Object resultObj = mongoTemplate.findOne(query, obj.getClass());
        return resultObj;
    }

    /**
     * 指定集合 根据条件查询出符合的第一条数据
     * 其实按照时间排序了 取最后一条
     *
     * @param obj            数据对象
     * @param findKeys       查询条件 key
     * @param findValues     查询条件 value
     * @param collectionName 集合名
     * @return
     */
    public Object findOne(Object obj, String[] findKeys, Object[] findValues, String collectionName, String sort) {
        Query query = getQuery(findKeys, findValues);
        query.with(new Sort(Direction.DESC, sort));
        Object resultObj = mongoTemplate.findOne(query, obj.getClass(), collectionName);
        return resultObj;
    }

    /**
     * 指定集合 根据条件查询出所有结果集 并排序
     *
     * @param obj            数据对象
     * @param findKeys       查询条件 key
     * @param findValues     查询条件 value
     * @param findKey        范围查找字段
     * @param gt             最小值
     * @param lt             最大值
     * @param collectionName 集合名
     * @param sortField      排序字段
     * @param sort           排序 DESC ASC
     * @return
     */
    public Object findOne(Object obj, String[] findKeys, Object[] findValues, String findKey, String gt, String lt, String collectionName, String sortField, String sort) {
        Query query = getQuery(findKeys, findValues, findKey, gt, lt);
        if ("DESC".equals(sort)) {
            query.with(new Sort(Direction.DESC, sortField));
        } else {
            query.with(new Sort(Direction.ASC, sortField));
        }
        Object resultObj = mongoTemplate.findOne(query, obj.getClass(), collectionName);
        return resultObj;
    }

    /**
     * 查询出所有结果集 集合为数据对象中 @Document 注解所配置的collection
     *
     * @param obj 数据对象
     * @return
     */
    public List<? extends Object> findAll(Object obj) {

        List<? extends Object> resultList = mongoTemplate.findAll(obj.getClass());
        return resultList;
    }

    /**
     * 指定集合 查询出所有结果集
     *
     * @param obj            数据对象
     * @param collectionName 集合名
     * @return
     */
    public List<? extends Object> findAll(Object obj, String collectionName) {
        List<? extends Object> resultList = mongoTemplate.findAll(obj.getClass(), collectionName);
        return resultList;
    }


    private Query getQuery(String[] findKeys, Object[] findValues) {

        Criteria criteria = null;
        for (int i = 0; i < findKeys.length; i++) {
            if (i == 0) {
                criteria = Criteria.where(findKeys[i]).is(findValues[i]);
            } else {
                criteria.and(findKeys[i]).is(findValues[i]);
            }
        }
        Query query = Query.query(criteria);
        return query;
    }

    private Query getQuery(String[] findKeys, Object[] findValues, String findKey, String gt, String lt) {
        Criteria criteria = null;
        for (int i = 0; i < findKeys.length; i++) {
            if (i == 0) {
                criteria = Criteria.where(findKeys[i]).is(findValues[i]);

                if (gt != null && lt != null) {
                    criteria.and(findKey).gte(gt).lte(lt);
                }
                if (lt != null && gt == null) {
                    criteria.and(findKey).lte(lt);
                }
                if (lt == null && gt != null) {
                    criteria.and(findKey).gte(gt);
                }
            } else {
                criteria.and(findKeys[i]).is(findValues[i]);
            }
        }

        Query query = Query.query(criteria);
        return query;
    }

    private Query getQuery(String findKey, String gt, String lt) {
        Criteria criteria = Criteria.where(findKey).gte(gt).lte(lt);

        Query query = Query.query(criteria);
        return query;
    }
}